/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2015 Blender Foundation.
 * All rights reserved.
 */

#include "openvdb_dense_convert.h"

#include <openvdb/tools/ValueTransformer.h> /* for tools::foreach */

namespace internal {

openvdb::Mat4R convertMatrix(const float mat[4][4])
{
  return openvdb::Mat4R(mat[0][0],
                        mat[0][1],
                        mat[0][2],
                        mat[0][3],
                        mat[1][0],
                        mat[1][1],
                        mat[1][2],
                        mat[1][3],
                        mat[2][0],
                        mat[2][1],
                        mat[2][2],
                        mat[2][3],
                        mat[3][0],
                        mat[3][1],
                        mat[3][2],
                        mat[3][3]);
}

class MergeScalarGrids {
  typedef openvdb::FloatTree ScalarTree;

  openvdb::tree::ValueAccessor<const ScalarTree> m_acc_x, m_acc_y, m_acc_z;

 public:
  MergeScalarGrids(const ScalarTree *x_tree, const ScalarTree *y_tree, const ScalarTree *z_tree)
      : m_acc_x(*x_tree), m_acc_y(*y_tree), m_acc_z(*z_tree)
  {
  }

  MergeScalarGrids(const MergeScalarGrids &other)
      : m_acc_x(other.m_acc_x), m_acc_y(other.m_acc_y), m_acc_z(other.m_acc_z)
  {
  }

  void operator()(const openvdb::Vec3STree::ValueOnIter &it) const
  {
    using namespace openvdb;

    const math::Coord xyz = it.getCoord();
    float x = m_acc_x.getValue(xyz);
    float y = m_acc_y.getValue(xyz);
    float z = m_acc_z.getValue(xyz);

    it.setValue(math::Vec3s(x, y, z));
  }
};

openvdb::GridBase *OpenVDB_export_vector_grid(OpenVDBWriter *writer,
                                              const openvdb::Name &name,
                                              const float *data_x,
                                              const float *data_y,
                                              const float *data_z,
                                              const int res[3],
                                              float fluid_mat[4][4],
                                              openvdb::VecType vec_type,
                                              const bool is_color,
                                              const float clipping,
                                              const openvdb::FloatGrid *mask)
{
  using namespace openvdb;

  math::CoordBBox bbox(Coord(0), Coord(res[0] - 1, res[1] - 1, res[2] - 1));
  Mat4R mat = convertMatrix(fluid_mat);
  math::Transform::Ptr transform = math::Transform::createLinearTransform(mat);

  FloatGrid::Ptr grid[3];

  grid[0] = FloatGrid::create(0.0f);
  tools::Dense<const float, tools::LayoutXYZ> dense_grid_x(bbox, data_x);
  tools::copyFromDense(dense_grid_x, grid[0]->tree(), clipping);

  grid[1] = FloatGrid::create(0.0f);
  tools::Dense<const float, tools::LayoutXYZ> dense_grid_y(bbox, data_y);
  tools::copyFromDense(dense_grid_y, grid[1]->tree(), clipping);

  grid[2] = FloatGrid::create(0.0f);
  tools::Dense<const float, tools::LayoutXYZ> dense_grid_z(bbox, data_z);
  tools::copyFromDense(dense_grid_z, grid[2]->tree(), clipping);

  Vec3SGrid::Ptr vecgrid = Vec3SGrid::create(Vec3s(0.0f));

  /* Activate voxels in the vector grid based on the scalar grids to ensure
   * thread safety later on */
  for (int i = 0; i < 3; ++i) {
    vecgrid->tree().topologyUnion(grid[i]->tree());
  }

  MergeScalarGrids op(&(grid[0]->tree()), &(grid[1]->tree()), &(grid[2]->tree()));
  tools::foreach (vecgrid->beginValueOn(), op, true, false);

  vecgrid->setTransform(transform);

  /* Avoid clipping against an empty grid. */
  if (mask && !mask->tree().empty()) {
    vecgrid = tools::clip(*vecgrid, *mask);
  }

  vecgrid->setName(name);
  vecgrid->setIsInWorldSpace(false);
  vecgrid->setVectorType(vec_type);
  vecgrid->insertMeta("is_color", BoolMetadata(is_color));
  vecgrid->setGridClass(GRID_STAGGERED);

  writer->insert(vecgrid);

  return vecgrid.get();
}

void OpenVDB_import_grid_vector(OpenVDBReader *reader,
                                const openvdb::Name &name,
                                float **data_x,
                                float **data_y,
                                float **data_z,
                                const int res[3])
{
  using namespace openvdb;

  if (!reader->hasGrid(name)) {
    std::fprintf(stderr, "OpenVDB grid %s not found in file!\n", name.c_str());
    memset(*data_x, 0, sizeof(float) * res[0] * res[1] * res[2]);
    memset(*data_y, 0, sizeof(float) * res[0] * res[1] * res[2]);
    memset(*data_z, 0, sizeof(float) * res[0] * res[1] * res[2]);
    return;
  }

  Vec3SGrid::Ptr vgrid = gridPtrCast<Vec3SGrid>(reader->getGrid(name));
  Vec3SGrid::ConstAccessor acc = vgrid->getConstAccessor();
  math::Coord xyz;
  int &x = xyz[0], &y = xyz[1], &z = xyz[2];

  size_t index = 0;
  for (z = 0; z < res[2]; ++z) {
    for (y = 0; y < res[1]; ++y) {
      for (x = 0; x < res[0]; ++x, ++index) {
        math::Vec3s value = acc.getValue(xyz);
        (*data_x)[index] = value.x();
        (*data_y)[index] = value.y();
        (*data_z)[index] = value.z();
      }
    }
  }
}

openvdb::Name do_name_versionning(const openvdb::Name &name)
{
  openvdb::Name temp_name = name;

  if (temp_name.find("_low", temp_name.size() - 4, 4) == temp_name.size() - 4) {
    return temp_name.replace(temp_name.size() - 4, 4, " low");
  }

  if (temp_name.find("_old", temp_name.size() - 4, 4) == temp_name.size() - 4) {
    return temp_name.replace(temp_name.size() - 4, 4, " old");
  }

  return temp_name;
}

} /* namespace internal */
